
package cn;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

import cn.drknt.lib.ACTIVATION;
import cn.drknt.lib.LAYER_TYPE;
import cn.wrapper.FILE;
import cn.wrapper.Learning_rate_policy;
import cn.wrapper.node;
import cn.wrapper.parser_wrapper;

public class parser extends parser_wrapper
{


//list *read_cfg(String filename);

static LAYER_TYPE string_to_layer_type(String  type)
{

    if (strcmp(type, "[shortcut]")==0) return LAYER_TYPE.SHORTCUT;
    if (strcmp(type, "[crop]")==0) return LAYER_TYPE.CROP;
    if (strcmp(type, "[cost]")==0) return LAYER_TYPE.COST;
    if (strcmp(type, "[detection]")==0) return LAYER_TYPE.DETECTION;
    if (strcmp(type, "[region]")==0) return LAYER_TYPE.REGION;
    if (strcmp(type, "[local]")==0) return LAYER_TYPE.LOCAL;
    if (strcmp(type, "[conv]")==0
            || strcmp(type, "[convolutional]")==0) return LAYER_TYPE.CONVOLUTIONAL;
    if (strcmp(type, "[deconv]")==0
            || strcmp(type, "[deconvolutional]")==0) return LAYER_TYPE.DECONVOLUTIONAL;
    if (strcmp(type, "[activation]")==0) return LAYER_TYPE.ACTIVE;
    if (strcmp(type, "[net]")==0
            || strcmp(type, "[network]")==0) return LAYER_TYPE.NETWORK;
    if (strcmp(type, "[crnn]")==0) return LAYER_TYPE.CRNN;
    if (strcmp(type, "[gru]")==0) return LAYER_TYPE.GRU;
    if (strcmp(type, "[lstm]") ==0) return LAYER_TYPE.LSTM;
    if (strcmp(type, "[rnn]")==0) return LAYER_TYPE.RNN;
    if (strcmp(type, "[conn]")==0
            || strcmp(type, "[connected]")==0) return LAYER_TYPE.CONNECTED;
    if (strcmp(type, "[max]")==0
            || strcmp(type, "[maxpool]")==0) return LAYER_TYPE.MAXPOOL;
    if (strcmp(type, "[reorg]")==0) return LAYER_TYPE.REORG;
    if (strcmp(type, "[avg]")==0
            || strcmp(type, "[avgpool]")==0) return LAYER_TYPE.AVGPOOL;
    if (strcmp(type, "[dropout]")==0) return LAYER_TYPE.DROPOUT;
    if (strcmp(type, "[lrn]")==0
            || strcmp(type, "[normalization]")==0) return LAYER_TYPE.NORMALIZATION;
    if (strcmp(type, "[batchnorm]")==0) return LAYER_TYPE.BATCHNORM;
    if (strcmp(type, "[soft]")==0
            || strcmp(type, "[softmax]")==0) return LAYER_TYPE.SOFTMAX;
    if (strcmp(type, "[route]")==0) return LAYER_TYPE.ROUTE;
    return LAYER_TYPE.BLANK;
}

static void free_section(section s)
{
    free(s.type);
    node n = s.options.front;
    while(n!=null){
        kvp pair = (kvp )n.val;
        free(pair.key);
        free(pair);
        node next = n.next;
        free(n);
        n = next;
    }
    free(s.options);
    free(s);
}

//void parse_data(String data, float []a, int n)
//{
//    int i;
//    if(!data) return;
//    String curr = data;
//    String next = data;
//    int done = 0;
//    for(i = 0; i < n && !done; ++i){
//        while(*++next !='\0' && *next != ',');
//        if(*next == '\0') done = 1;
//        *next = '\0';
//        sscanf(curr, "%g", &a[i]);
//        curr = next+1;
//    }
//}


//local_layer parse_local(list options, size_params params)
//{
//    int n = option_find_int(options, "filters",1);
//    int size = option_find_int(options, "size",1);
//    int stride = option_find_int(options, "stride",1);
//    int pad = option_find_int(options, "pad",0);
//    String activation_s = option_find_str(options, "activation", "logistic");
//    ACTIVATION activation = get_activation(activation_s);
//
//    int batch,h,w,c;
//    h = params.h;
//    w = params.w;
//    c = params.c;
//    batch=params.batch;
//    if(!(h && w && c)) error("Layer before local layer must output image.");
//
//    local_layer layer = make_local_layer(batch,h,w,c,n,size,stride,pad,activation);
//
//    return layer;
//}

//layer parse_deconvolutional(list options, size_params params)
//{
//    int n = option_find_int(options, "filters",1);
//    int size = option_find_int(options, "size",1);
//    int stride = option_find_int(options, "stride",1);
//
//    String activation_s = option_find_str(options, "activation", "logistic");
//    ACTIVATION activation = get_activation(activation_s);
//
//    int batch,h,w,c;
//    h = params.h;
//    w = params.w;
//    c = params.c;
//    batch=params.batch;
//    if(!(h>0 && w>0 && c>0)) error("Layer before deconvolutional layer must output image.");
//    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
//    int pad = option_find_int_quiet(options, "pad",0);
//    int padding = option_find_int_quiet(options, "padding",0);
//    if(pad>0) padding = size/2;//sjx
//
//    layer l = make_deconvolutional_layer(batch,h,w,c,n,size,stride,padding, activation, batch_normalize, params.net.adam);
//
//    return l;
//}


static convolutional_layer parse_convolutional(list options, size_params params)
{
    int n = option_find_int(options, "filters",1);
    int size = option_find_int(options, "size",1);
    int stride = option_find_int(options, "stride",1);
    int pad = option_find_int_quiet(options, "pad",0);
    int padding = option_find_int_quiet(options, "padding",0);
    int groups = option_find_int_quiet(options, "groups", 1);
    if(pad>0) padding = size/2;

    String activation_s = option_find_str(options, "activation", "logistic");
    ACTIVATION activation = get_activation(activation_s);

    int batch,h,w,c;
    h = params.h;
    w = params.w;
    c = params.c;
    batch=params.batch;
    if(!(h>0 && w>0 && c>0)) utils.error("Layer before convolutional layer must output image.");
    boolean batch_normalize = option_find_boolean_quiet(options, "batch_normalize", 0);
    boolean binary = option_find_boolean_quiet(options, "binary", 0);
    boolean xnor = option_find_boolean_quiet(options, "xnor", 0);

    convolutional_layer layer = make_convolutional_layer(batch,h,w,c,n,groups,size,stride,padding,activation, batch_normalize, binary, xnor, params.net.adam);
    layer.flipped = option_find_boolean_quiet(options, "flipped", 0);
    layer.dot = option_find_float_quiet(options, "dot", 0);

    return layer;
}

//layer parse_crnn(list options, size_params params)
//{
//    int output_filters = option_find_int(options, "output_filters",1);
//    int hidden_filters = option_find_int(options, "hidden_filters",1);
//    String activation_s = option_find_str(options, "activation", "logistic");
//    ACTIVATION activation = get_activation(activation_s);
//    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
//
//    layer l = make_crnn_layer(params.batch, params.w, params.h, params.c, hidden_filters, output_filters, params.time_steps, activation, batch_normalize);
//
//    l.shortcut = option_find_int_quiet(options, "shortcut", 0);
//
//    return l;
//}

//layer parse_rnn(list options, size_params params)
//{
//    int output = option_find_int(options, "output",1);
//    String activation_s = option_find_str(options, "activation", "logistic");
//    ACTIVATION activation = get_activation(activation_s);
//    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
//
//    layer l = make_rnn_layer(params.batch, params.inputs, output, params.time_steps, activation, batch_normalize, params.net.adam);
//
//    l.shortcut = option_find_int_quiet(options, "shortcut", 0);
//
//    return l;
//}

//layer parse_gru(list options, size_params params)
//{
//    int output = option_find_int(options, "output",1);
//    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
//
//    layer l = make_gru_layer(params.batch, params.inputs, output, params.time_steps, batch_normalize, params.net.adam);
//    l.tanh = option_find_int_quiet(options, "tanh", 0);
//
//    return l;
//}

//layer parse_lstm(list options, size_params params)
//{
//    int output = option_find_int(options, "output", 1);
//    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
//
//    layer l = make_lstm_layer(params.batch, params.inputs, output, params.time_steps, batch_normalize, params.net.adam);
//
//    return l;
//}

//layer parse_connected(list options, size_params params)
//{
//    int output = option_find_int(options, "output",1);
//    String activation_s = option_find_str(options, "activation", "logistic");
//    ACTIVATION activation = get_activation(activation_s);
//    int batch_normalize = option_find_int_quiet(options, "batch_normalize", 0);
//
//    layer l = make_connected_layer(params.batch, params.inputs, output, activation, batch_normalize, params.net.adam);
//    return l;
//}

//softmax_layer parse_softmax(list options, size_params params)
//{
//    int groups = option_find_int_quiet(options, "groups",1);
//    softmax_layer layer = make_softmax_layer(params.batch, params.inputs, groups);
//    layer.temperature = option_find_float_quiet(options, "temperature", 1);
//    String tree_file = option_find_str(options, "tree", 0);
//    if (tree_file) layer.softmax_tree = read_tree(tree_file);
//    layer.w = params.w;
//    layer.h = params.h;
//    layer.c = params.c;
//    layer.spatial = option_find_float_quiet(options, "spatial", 0);
//    return layer;
//}

static layer parse_region(list options, size_params params)
{
    int coords = option_find_int(options, "coords", 4);
    int classes = option_find_int(options, "classes", 20);
    int num = option_find_int(options, "num", 1);

    layer l = make_region_layer(params.batch, params.w, params.h, num, classes, coords);
    assert(l.outputs == params.inputs);

    l.log = option_find_int_quiet(options, "log", 0);
    l.sqrt = option_find_int_quiet(options, "sqrt", 0);

    l.softmax = option_find_boolean(options, "softmax", 0);
    l.background = option_find_boolean_quiet(options, "background", 0);
    l.max_boxes = option_find_int_quiet(options, "max",30);
    l.jitter = option_find_float(options, "jitter", .2);
    l.rescore = option_find_boolean_quiet(options, "rescore",0);

    l.thresh = option_find_float(options, "thresh", .5);
    l.classfix = option_find_int_quiet(options, "classfix", 0);
    l.absolute = option_find_int_quiet(options, "absolute", 0);
    l.random = option_find_boolean_quiet(options, "random", 0);

    l.coord_scale = option_find_float(options, "coord_scale", 1);
    l.object_scale = option_find_float(options, "object_scale", 1);
    l.noobject_scale = option_find_float(options, "noobject_scale", 1);
    l.mask_scale = option_find_float(options, "mask_scale", 1);
    l.class_scale = option_find_float(options, "class_scale", 1);
    l.bias_match = option_find_boolean_quiet(options, "bias_match",0);

    String tree_file = option_find_str(options, "tree", 0);
    if (tree_file!=null) l.softmax_tree = read_tree(tree_file);
    String map_file = option_find_str(options, "map", 0);
    if (map_file!=null) l.map = read_map(map_file);

    String a = option_find_str(options, "anchors", 0);
    if(a!=null){
//        int len = strlen(a);
//        int n = 1;
//        int i;
//        for(i = 0; i < len; ++i){
//            if (a[i] == ',') ++n;
//        }
//        for(i = 0; i < n; ++i){
//            float bias = atof(a);
//            l.biases[i] = bias;
//            a = strchr(a, ',')+1;
//        }
    	float[] anchors=utils.splitFloat(a);
    	for (int i = 0; i < anchors.length; i++) {
    		l.biases[i]=anchors[i];
		}
    }
    return l;
}
//detection_layer parse_detection(list options, size_params params)
//{
//    int coords = option_find_int(options, "coords", 1);
//    int classes = option_find_int(options, "classes", 1);
//    int rescore = option_find_int(options, "rescore", 0);
//    int num = option_find_int(options, "num", 1);
//    int side = option_find_int(options, "side", 7);
//    detection_layer layer = make_detection_layer(params.batch, params.inputs, num, side, classes, coords, rescore);
//
//    layer.softmax = option_find_int(options, "softmax", 0);
//    layer.sqrt = option_find_int(options, "sqrt", 0);
//
//    layer.max_boxes = option_find_int_quiet(options, "max",30);
//    layer.coord_scale = option_find_float(options, "coord_scale", 1);
//    layer.forced = option_find_int(options, "forced", 0);
//    layer.object_scale = option_find_float(options, "object_scale", 1);
//    layer.noobject_scale = option_find_float(options, "noobject_scale", 1);
//    layer.class_scale = option_find_float(options, "class_scale", 1);
//    layer.jitter = option_find_float(options, "jitter", .2);
//    layer.random = option_find_int_quiet(options, "random", 0);
//    layer.reorg = option_find_int_quiet(options, "reorg", 0);
//    return layer;
//}

//cost_layer parse_cost(list options, size_params params)
//{
//    String type_s = option_find_str(options, "type", "sse");
//    COST_TYPE type = get_cost_type(type_s);
//    float scale = option_find_float_quiet(options, "scale",1);
//    cost_layer layer = make_cost_layer(params.batch, params.inputs, type, scale);
//    layer.ratio =  option_find_float_quiet(options, "ratio",0);
//    layer.noobject_scale =  option_find_float_quiet(options, "noobj", 1);
//    layer.thresh =  option_find_float_quiet(options, "thresh",0);
//    return layer;
//}

//crop_layer parse_crop(list options, size_params params)
//{
//    int crop_height = option_find_int(options, "crop_height",1);
//    int crop_width = option_find_int(options, "crop_width",1);
//    int flip = option_find_int(options, "flip",0);
//    float angle = option_find_float(options, "angle",0);
//    float saturation = option_find_float(options, "saturation",1);
//    float exposure = option_find_float(options, "exposure",1);
//
//    int batch,h,w,c;
//    h = params.h;
//    w = params.w;
//    c = params.c;
//    batch=params.batch;
//    if(!(h && w && c)) error("Layer before crop layer must output image.");
//
//    int noadjust = option_find_int_quiet(options, "noadjust",0);
//
//    crop_layer l = make_crop_layer(batch,h,w,c,crop_height,crop_width,flip, angle, saturation, exposure);
//    l.shift = option_find_float(options, "shift", 0);
//    l.noadjust = noadjust;
//    return l;
//}

//layer parse_reorg(list options, size_params params)
//{
//    int stride = option_find_int(options, "stride",1);
//    int reverse = option_find_int_quiet(options, "reverse",0);
//    int flatten = option_find_int_quiet(options, "flatten",0);
//    int extra = option_find_int_quiet(options, "extra",0);
//
//    int batch,h,w,c;
//    h = params.h;
//    w = params.w;
//    c = params.c;
//    batch=params.batch;
//    if(!(h && w && c)) error("Layer before reorg layer must output image.");
//
//    layer layer = make_reorg_layer(batch,w,h,c,stride,reverse, flatten, extra);
//    return layer;
//}

static maxpool_layer parse_maxpool(list options, size_params params)
{
    int stride = option_find_int(options, "stride",1);
    int size = option_find_int(options, "size",stride);
    int padding = option_find_int_quiet(options, "padding", (size-1)/2);

    int batch,h,w,c;
    h = params.h;
    w = params.w;
    c = params.c;
    batch=params.batch;
    if(!(h>0 && w>0 && c>0)) utils.error("Layer before maxpool layer must output image.");

    maxpool_layer layer = make_maxpool_layer(batch,h,w,c,size,stride,padding);
    return layer;
}

//avgpool_layer parse_avgpool(list options, size_params params)
//{
//    int batch,w,h,c;
//    w = params.w;
//    h = params.h;
//    c = params.c;
//    batch=params.batch;
//    if(!(h && w && c)) error("Layer before avgpool layer must output image.");
//
//    avgpool_layer layer = make_avgpool_layer(batch,w,h,c);
//    return layer;
//}

//dropout_layer parse_dropout(list options, size_params params)
//{
//    float probability = option_find_float(options, "probability", .5);
//    dropout_layer layer = make_dropout_layer(params.batch, params.inputs, probability);
//    layer.out_w = params.w;
//    layer.out_h = params.h;
//    layer.out_c = params.c;
//    return layer;
//}

//layer parse_normalization(list options, size_params params)
//{
//    float alpha = option_find_float(options, "alpha", .0001);
//    float beta =  option_find_float(options, "beta" , .75);
//    float kappa = option_find_float(options, "kappa", 1);
//    int size = option_find_int(options, "size", 5);
//    layer l = make_normalization_layer(params.batch, params.w, params.h, params.c, size, alpha, beta, kappa);
//    return l;
//}

//layer parse_batchnorm(list options, size_params params)
//{
//    layer l = make_batchnorm_layer(params.batch, params.w, params.h, params.c);
//    return l;
//}

//layer parse_shortcut(list options, size_params params, network net)
//{
//    String l = option_find(options, "from");
//    int index = atoi(l);
//    if(index < 0) index = params.index + index;
//
//    int batch = params.batch;
//    layer from = net.layers[index];
//
//    layer s = make_shortcut_layer(batch, index, params.w, params.h, params.c, from.out_w, from.out_h, from.out_c);
//
//    String activation_s = option_find_str(options, "activation", "linear");
//    ACTIVATION activation = get_activation(activation_s);
//    s.activation = activation;
//    return s;
//}


//layer parse_activation(list options, size_params params)
//{
//    String activation_s = option_find_str(options, "activation", "linear");
//    ACTIVATION activation = get_activation(activation_s);
//
//    layer l = make_activation_layer(params.batch, params.inputs, activation);
//
//    l.out_h = params.h;
//    l.out_w = params.w;
//    l.out_c = params.c;
//    l.h = params.h;
//    l.w = params.w;
//    l.c = params.c;
//
//    return l;
//}

//route_layer parse_route(list options, size_params params, network net)
//{
//    String l = option_find(options, "layers");
//    int len = strlen(l);
//    if(!l) error("Route Layer must specify input layers");
//    int n = 1;
//    int i;
//    for(i = 0; i < len; ++i){
//        if (l[i] == ',') ++n;
//    }
//
//    int[] layers = calloc(n, 1/*sizeof(int)*/);
//    int[] sizes = calloc(n, 1/*sizeof(int)*/);
//    for(i = 0; i < n; ++i){
//        int index = atoi(l);
//        l = strchr(l, ',')+1;
//        if(index < 0) index = params.index + index;
//        layers[i] = index;
//        sizes[i] = net.layers[index].outputs;
//    }
//    int batch = params.batch;
//
//    route_layer layer = make_route_layer(batch, n, layers, sizes);
//
//    convolutional_layer first = net.layers[layers[0]];
//    layer.out_w = first.out_w;
//    layer.out_h = first.out_h;
//    layer.out_c = first.out_c;
//    for(i = 1; i < n; ++i){
//        int index = layers[i];
//        convolutional_layer next = net.layers[index];
//        if(next.out_w == first.out_w && next.out_h == first.out_h){
//            layer.out_c += next.out_c;
//        }else{
//            layer.out_h = layer.out_w = layer.out_c = 0;
//        }
//    }
//
//    return layer;
//}

static Learning_rate_policy get_policy(String s)
{
    if (strcmp(s, "random")==0) return Learning_rate_policy.RANDOM;
    if (strcmp(s, "poly")==0) return Learning_rate_policy.POLY;
    if (strcmp(s, "constant")==0) return Learning_rate_policy.CONSTANT;
    if (strcmp(s, "step")==0) return Learning_rate_policy.STEP;
    if (strcmp(s, "exp")==0) return Learning_rate_policy.EXP;
    if (strcmp(s, "sigmoid")==0) return Learning_rate_policy.SIG;
    if (strcmp(s, "steps")==0) return Learning_rate_policy.STEPS;
    fprintf(stderr, "Couldn't find policy %s, going with constant\n", s);
    return Learning_rate_policy.CONSTANT;
}

static void parse_net_options(list options, network net)
{
    net.batch = option_find_int(options, "batch",1);
    net.learning_rate = option_find_float(options, "learning_rate", .001);
    net.momentum = option_find_float(options, "momentum", .9);
    net.decay = option_find_float(options, "decay", .0001);
    int subdivs = option_find_int(options, "subdivisions",1);
    net.time_steps = option_find_int_quiet(options, "time_steps",1);
    net.notruth = option_find_int_quiet(options, "notruth",0);
    net.batch /= subdivs;
    net.batch *= net.time_steps;
    net.subdivisions = subdivs;
    net.random = option_find_int_quiet(options, "random", 0);

    net.adam = option_find_boolean_quiet(options, "adam", 0);
    if(net.adam){
        net.B1 = option_find_float(options, "B1", .9);
        net.B2 = option_find_float(options, "B2", .999);
        net.eps = option_find_float(options, "eps", .0000001);
    }

    net.h = option_find_int_quiet(options, "height",0);
    net.w = option_find_int_quiet(options, "width",0);
    net.c = option_find_int_quiet(options, "channels",0);
    net.inputs = option_find_int_quiet(options, "inputs", net.h * net.w * net.c);
    net.max_crop = option_find_int_quiet(options, "max_crop",net.w*2);
    net.min_crop = option_find_int_quiet(options, "min_crop",net.w);
    net.max_ratio = option_find_float_quiet(options, "max_ratio", (float) net.max_crop / net.w);
    net.min_ratio = option_find_float_quiet(options, "min_ratio", (float) net.min_crop / net.w);
    net.center = option_find_int_quiet(options, "center",0);

    net.angle = option_find_float_quiet(options, "angle", 0);
    net.aspect = option_find_float_quiet(options, "aspect", 1);
    net.saturation = option_find_float_quiet(options, "saturation", 1);
    net.exposure = option_find_float_quiet(options, "exposure", 1);
    net.hue = option_find_float_quiet(options, "hue", 0);

    if(0==net.inputs && !(net.h>0 && net.w>0 && net.c>0)) error("No input parameters supplied");

    String policy_s = option_find_str(options, "policy", "constant");
    net.policy = get_policy(policy_s);
    net.burn_in = option_find_int_quiet(options, "burn_in", 0);
    net.power = option_find_float_quiet(options, "power", 4);
    if(net.policy == Learning_rate_policy.STEP){
        net.step = option_find_int(options, "step", 1);
        net.scale = option_find_float(options, "scale", 1);
    } else if (net.policy == Learning_rate_policy.STEPS){
        String l = option_find(options, "steps");
        String p = option_find(options, "scales");
        if(null==l || null==p) error("STEPS policy must have steps and scales in cfg file");

//        int len = strlen(l);
//        int n = 1;
//        int i;
//        for(i = 0; i < len; ++i){
//            if (l[i] == ',') ++n;
//        }
//        int[] steps = callocInt(n, 1/*sizeof(int)*/);
//        float []scales = calloc(n, 1/*sizeof(float)*/);
//        for(i = 0; i < n; ++i){
//            int step    = atoi(l);
//            float scale = atof(p);
//            l = strchr(l, ',')+1;
//            p = strchr(p, ',')+1;
//            steps[i] = step;
//            scales[i] = scale;
//        }
//        net.scales = scales;
//        net.steps = steps;
//        net.num_steps = n;
        net.scales = splitFloat(p);
        net.steps = splitInt(l);
        net.num_steps = (net.scales.length<net.steps.length)?net.scales.length:net.steps.length;
        if(net.scales.length!=net.steps.length) {
        	System.err.println("steps.length<>scales.length");
        }
    } else if (net.policy == Learning_rate_policy.EXP){
        net.gamma = option_find_float(options, "gamma", 1);
    } else if (net.policy == Learning_rate_policy.SIG){
        net.gamma = option_find_float(options, "gamma", 1);
        net.step = option_find_int(options, "step", 1);
    } else if (net.policy == Learning_rate_policy.POLY || net.policy == Learning_rate_policy.RANDOM){
    }
    net.max_batches = option_find_int(options, "max_batches", 0);
}

static boolean is_network(section s)
{
    return (strcmp(s.type, "[net]")==0
            || strcmp(s.type, "[network]")==0);
}

public static network parse_network_cfg(String filename) throws IOException, Exception
{
    list sections = read_cfg(filename);
    node n = sections.front;
    if(null==n) utils.error("Config file has no sections");
    network net = make_network(sections.size - 1);
    net.gpu_index = gpu_index;
    size_params params=new size_params();

    section s = (section)n.val;
    list options = s.options;
    if(!is_network(s)) utils.error("First section must be [net] or [network]");
    parse_net_options(options, net);

    params.h = net.h;
    params.w = net.w;
    params.c = net.c;
    params.inputs = net.inputs;
    params.batch = net.batch;
    params.time_steps = net.time_steps;
    params.net = net;

    /*size_t*/int workspace_size = 0;
    n = n.next;
    int count = 0;
    free_section(s);
    fprintf(stderr, "layer     filters    size              input                output\n");
    while(n!=null){
        params.index = count;
        fprintf(stderr, "%5d ", count);
        s = (section)n.val;
        options = s.options;
        layer l = null;//{0};
        LAYER_TYPE lt = string_to_layer_type(s.type);
        if(lt == LAYER_TYPE.CONVOLUTIONAL){
            l = parse_convolutional(options, params);
        }
//        else if(lt == LAYER_TYPE.DECONVOLUTIONAL){
//            l = parse_deconvolutional(options, params);
//        }else if(lt == LAYER_TYPE.LOCAL){
//            l = parse_local(options, params);
//        }else if(lt == LAYER_TYPE.ACTIVE){
//            l = parse_activation(options, params);
//        }else if(lt == LAYER_TYPE.RNN){
//            l = parse_rnn(options, params);
//        }else if(lt == LAYER_TYPE.GRU){
//            l = parse_gru(options, params);
//        }else if (lt == LAYER_TYPE.LSTM) {
//            l = parse_lstm(options, params);
//        }else if(lt == LAYER_TYPE.CRNN){
//            l = parse_crnn(options, params);
//        }else if(lt == LAYER_TYPE.CONNECTED){
//            l = parse_connected(options, params);
//        }else if(lt == LAYER_TYPE.CROP){
//            l = parse_crop(options, params);
//        }else if(lt == LAYER_TYPE.COST){
//            l = parse_cost(options, params);
//        }
        else if(lt == LAYER_TYPE.REGION){
            l = parse_region(options, params);
        }
//        else if(lt == LAYER_TYPE.DETECTION){
//            l = parse_detection(options, params);
//        }else if(lt == LAYER_TYPE.SOFTMAX){
//            l = parse_softmax(options, params);
//            net.hierarchy = l.softmax_tree;
//        }else if(lt == LAYER_TYPE.NORMALIZATION){
//            l = parse_normalization(options, params);
//        }else if(lt == LAYER_TYPE.BATCHNORM){
//            l = parse_batchnorm(options, params);
//        }
        else if(lt == LAYER_TYPE.MAXPOOL){
            l = parse_maxpool(options, params);
        }
//        else if(lt == LAYER_TYPE.REORG){
//            l = parse_reorg(options, params);
//        }else if(lt == LAYER_TYPE.AVGPOOL){
//            l = parse_avgpool(options, params);
//        }else if(lt == LAYER_TYPE.ROUTE){
//            l = parse_route(options, params, net);
//        }else if(lt == LAYER_TYPE.SHORTCUT){
//            l = parse_shortcut(options, params, net);
//        }else if(lt == LAYER_TYPE.DROPOUT){
//            l = parse_dropout(options, params);
//            l.output = net.layers[count-1].output;
//            l.delta = net.layers[count-1].delta;
////#ifdef GPU
////            l.output_gpu = net.layers[count-1].output_gpu;
////            l.delta_gpu = net.layers[count-1].delta_gpu;
////#endif
//        }
        else{
            fprintf(stderr, "Type not recognized: %s\n", s.type);
        }
        l.truth = option_find_int_quiet(options, "truth", 0);
        l.onlyforward = option_find_int_quiet(options, "onlyforward", 0);
        l.stopbackward = option_find_boolean_quiet(options, "stopbackward", 0);
        l.dontload = option_find_boolean_quiet(options, "dontload", 0);
        l.dontloadscales = option_find_boolean_quiet(options, "dontloadscales", 0);
        l.learning_rate_scale = option_find_float_quiet(options, "learning_rate", 1);
        l.smooth = option_find_float_quiet(options, "smooth", 0);
        option_unused(options);
        net.layers[count] = l;
        if (l.workspace_size > workspace_size) workspace_size = l.workspace_size;
        free_section(s);
        n = n.next;
        ++count;
        if(n!=null){
            params.h = l.out_h;
            params.w = l.out_w;
            params.c = l.out_c;
            params.inputs = l.outputs;
        }
    }
    free_list(sections);
    layer out = get_network_output_layer(net);
    net.outputs = out.outputs;
    net.truths = out.outputs;
    if(net.layers[net.n-1].truths!=0) net.truths = net.layers[net.n-1].truths;
    net.output = out.output;
    net.input = calloc(net.inputs*net.batch, 1/*sizeof(float)*/);
    net.truth = calloc(net.truths*net.batch, 1/*sizeof(float)*/);
//#ifdef GPU
//    net.output_gpu = out.output_gpu;
//    net.input_gpu = cuda_make_array(net.input, net.inputs*net.batch);
//    net.truth_gpu = cuda_make_array(net.truth, net.truths*net.batch);
//#endif
    if(workspace_size>0){
        //printf("%ld\n", workspace_size);
//#ifdef GPU
//        if(gpu_index >= 0){
//            net.workspace = cuda_make_array(0, (workspace_size-1)/1/*sizeof(float)*/+1);
//        }else {
//            net.workspace = calloc(1, workspace_size);
//        }
//#else
        net.workspace = calloc(1, workspace_size);
//#endif
    }
    return net;
}

//public static list read_cfg(String filename)
//{
//    FILE *file = fopen(filename, "r");
//    if(file == 0) file_error(filename);
//    String line;
//    int nu = 0;
//    list *options = make_list();
//    section *current = 0;
//    while((line=fgetl(file)) != 0){
//        ++ nu;
//        strip(line);
//        switch(line[0]){
//            case '[':
//                current = malloc(sizeof(section));
//                list_insert(options, current);
//                current.options = make_list();
//                current.type = line;
//                break;
//            case '\0':
//            case '#':
//            case ';':
//                free(line);
//                break;
//            default:
//                if(!read_option(line, current.options)){
//                    fprintf(stderr, "Config file error line %d, could parse: %s\n", nu, line);
//                    free(line);
//                }
//                break;
//        }
//    }
//    fclose(file);
//    return options;
//}
static list read_cfg(String filename)throws IOException, Exception
{
//    FILE *file = fopen(filename, "r");
	File file=new File(filename);
    if(!file.exists()) utils.file_error(filename);
    BufferedReader fp=new BufferedReader(new FileReader(file));
    String line;
    int nu = 0;
    list options = list.make_list();
    section current = null;
    while((line=fp.readLine()) != null){
        ++ nu;
//        strip(line);
        line=line.trim();
        if(line.length()==0)continue;
        switch(line.charAt(0)){
            case '[':
                current = new section();//malloc(sizeof(section));
                list_insert(options, current);
                current.options=list.make_list();
                current.type=line;
                break;
            case '\0':
            case '#':
            case ';':
//                free(line);
                break;
            default:
                if(!option_list.read_option(line, current.options)){
//                    fprintf(stderr, "Config file error line %d, could parse: %s\n", nu, line);
                	System.err.print("Config file error line "+nu+", could parse: "+line+"\n");
//                    free(line);
                }
                break;
        }
    }
//    fclose(fp);
    fp.close();
    return options;
}
void save_convolutional_weights_binary(layer l, FILE fp)throws IOException, Exception
{
//#ifdef GPU
//    if(gpu_index >= 0){
//        pull_convolutional_layer(l);
//    }
//#endif
    binarize_weights(l.weights, l.n, l.c*l.size*l.size, l.binary_weights);
    int size = l.c*l.size*l.size;
    int i, j, k;
    fwrite(l.biases, 1/*sizeof(float)*/, l.n, fp);
    if (l.batch_normalize){
        fwrite(l.scales, 1/*sizeof(float)*/, l.n, fp);
        fwrite(l.rolling_mean, 1/*sizeof(float)*/, l.n, fp);
        fwrite(l.rolling_variance, 1/*sizeof(float)*/, l.n, fp);
    }
    for(i = 0; i < l.n; ++i){
        float mean = l.binary_weights[i*size];
        if(mean < 0) mean = -mean;
        fwrite(mean, 1/*sizeof(float)*/, 1, fp);
        for(j = 0; j < size/8; ++j){
            int index = i*size + j*8;
            /*unsigned char*/ int c = 0;
            for(k = 0; k < 8; ++k){
                if (j*8 + k >= size) break;
                if (l.binary_weights[index + k] > 0) c = (c | 1<<k);
            }
            fwrite(c, 1/*sizeof(char)*/, 1, fp);
        }
    }
}

static void save_convolutional_weights(layer l, FILE fp)throws IOException, Exception
{
    if(l.binary){
        //save_convolutional_weights_binary(l, fp);
        //return;
    }
//#ifdef GPU
//    if(gpu_index >= 0){
//        pull_convolutional_layer(l);
//    }
//#endif
    int num = l.nweights;
    fwrite(l.biases, 1/*sizeof(float)*/, l.n, fp);
    if (l.batch_normalize){
        fwrite(l.scales, 1/*sizeof(float)*/, l.n, fp);
        fwrite(l.rolling_mean, 1/*sizeof(float)*/, l.n, fp);
        fwrite(l.rolling_variance, 1/*sizeof(float)*/, l.n, fp);
    }
    fwrite(l.weights, 1/*sizeof(float)*/, num, fp);
}

static void save_batchnorm_weights(layer l, FILE fp)throws IOException, Exception
{
//#ifdef GPU
//    if(gpu_index >= 0){
//        pull_batchnorm_layer(l);
//    }
//#endif
    fwrite(l.scales, 1/*sizeof(float)*/, l.c, fp);
    fwrite(l.rolling_mean, 1/*sizeof(float)*/, l.c, fp);
    fwrite(l.rolling_variance, 1/*sizeof(float)*/, l.c, fp);
}

static void save_connected_weights(layer l, FILE fp)throws IOException, Exception
{
//#ifdef GPU
//    if(gpu_index >= 0){
//        pull_connected_layer(l);
//    }
//#endif
    fwrite(l.biases, 1/*sizeof(float)*/, l.outputs, fp);
    fwrite(l.weights, 1/*sizeof(float)*/, l.outputs*l.inputs, fp);
    if (l.batch_normalize){
        fwrite(l.scales, 1/*sizeof(float)*/, l.outputs, fp);
        fwrite(l.rolling_mean, 1/*sizeof(float)*/, l.outputs, fp);
        fwrite(l.rolling_variance, 1/*sizeof(float)*/, l.outputs, fp);
    }
}

static void save_weights_upto(network net, String filename, int cutoff) throws Exception
{
//#ifdef GPU
//    if(net.gpu_index >= 0){
//        cuda_set_device(net.gpu_index);
//    }
//#endif
    fprintf(stderr, "Saving weights to %s\n", filename);
//    FILE *fp = fopen(filename, "wb");
//    if(!fp) file_error(filename);
    FILE fp = fopen(filename, "wb");
    if(null==fp) file_error(filename);
    
    int major = 0;
    int minor = 2;
    int revision = 0;
    fwrite(major, 1/*sizeof(int)*/, 1, fp);
    fwrite(minor, 1/*sizeof(int)*/, 1, fp);
    fwrite(revision, 1/*sizeof(int)*/, 1, fp);
    fwrite(net.seen[0], 1/*sizeof(size_t)*/, 1, fp);

    int i;
    for(i = 0; i < net.n && i < cutoff; ++i){
        layer l = net.layers[i];
        if(l.type == LAYER_TYPE.CONVOLUTIONAL || l.type == LAYER_TYPE.DECONVOLUTIONAL){
            save_convolutional_weights(l, fp);
        } if(l.type == LAYER_TYPE.CONNECTED){
            save_connected_weights(l, fp);
        } if(l.type == LAYER_TYPE.BATCHNORM){
            save_batchnorm_weights(l, fp);
        } if(l.type == LAYER_TYPE.RNN){
            save_connected_weights((l.input_layer), fp);
            save_connected_weights((l.self_layer), fp);
            save_connected_weights((l.output_layer), fp);
        } if (l.type == LAYER_TYPE.LSTM) {
            save_connected_weights((l.wi), fp);
            save_connected_weights((l.wf), fp);
            save_connected_weights((l.wo), fp);
            save_connected_weights((l.wg), fp);
            save_connected_weights((l.ui), fp);
            save_connected_weights((l.uf), fp);
            save_connected_weights((l.uo), fp);
            save_connected_weights((l.ug), fp);
        } if (l.type == LAYER_TYPE.GRU) {
            if(true/*1*/){
                save_connected_weights((l.wz), fp);
                save_connected_weights((l.wr), fp);
                save_connected_weights((l.wh), fp);
                save_connected_weights((l.uz), fp);
                save_connected_weights((l.ur), fp);
                save_connected_weights((l.uh), fp);
            }else{
                save_connected_weights((l.reset_layer), fp);
                save_connected_weights((l.update_layer), fp);
                save_connected_weights((l.state_layer), fp);
            }
        }  if(l.type == LAYER_TYPE.CRNN){
            save_convolutional_weights((l.input_layer), fp);
            save_convolutional_weights((l.self_layer), fp);
            save_convolutional_weights((l.output_layer), fp);
        } if(l.type == LAYER_TYPE.LOCAL){
//#ifdef GPU
//            if(gpu_index >= 0){
//                pull_local_layer(l);
//            }
//#endif
            int locations = l.out_w*l.out_h;
            int size = l.size*l.size*l.c*l.n*locations;
            fwrite(l.biases, 1/*sizeof(float)*/, l.outputs, fp);
            fwrite(l.weights, 1/*sizeof(float)*/, size, fp);
        }
    }
    fclose(fp);
}
public static void save_weights(network net, String filename) throws Exception
{
    save_weights_upto(net, filename, net.n);
}

static void transpose_matrix(float []a, int rows, int cols)
{
    float []transpose = calloc(rows*cols, 1/*sizeof(float)*/);
    int x, y;
    for(x = 0; x < rows; ++x){
        for(y = 0; y < cols; ++y){
            transpose[y*rows + x] = a[x*cols + y];
        }
    }
    memcpy(a, transpose, rows*cols*1/*sizeof(float)*/);
    free(transpose);
}

static void load_connected_weights(layer l, FILE fp, boolean transpose) throws IOException
{
    fread(l.biases, 1/*sizeof(float)*/, l.outputs, fp);
    fread(l.weights, 1/*sizeof(float)*/, l.outputs*l.inputs, fp);
    if(transpose){
        transpose_matrix(l.weights, l.inputs, l.outputs);
    }
    //printf("Biases: %f mean %f variance\n", mean_array(l.biases, l.outputs), variance_array(l.biases, l.outputs));
    //printf("Weights: %f mean %f variance\n", mean_array(l.weights, l.outputs*l.inputs), variance_array(l.weights, l.outputs*l.inputs));
    if (l.batch_normalize && (!l.dontloadscales)){
        fread(l.scales, 1/*sizeof(float)*/, l.outputs, fp);
        fread(l.rolling_mean, 1/*sizeof(float)*/, l.outputs, fp);
        fread(l.rolling_variance, 1/*sizeof(float)*/, l.outputs, fp);
        //printf("Scales: %f mean %f variance\n", mean_array(l.scales, l.outputs), variance_array(l.scales, l.outputs));
        //printf("rolling_mean: %f mean %f variance\n", mean_array(l.rolling_mean, l.outputs), variance_array(l.rolling_mean, l.outputs));
        //printf("rolling_variance: %f mean %f variance\n", mean_array(l.rolling_variance, l.outputs), variance_array(l.rolling_variance, l.outputs));
    }
//#ifdef GPU
//    if(gpu_index >= 0){
//        push_connected_layer(l);
//    }
//#endif
}
//
static void load_batchnorm_weights(layer l, FILE fp) throws IOException
{
    fread(l.scales, 1/*sizeof(float)*/, l.c, fp);
    fread(l.rolling_mean, 1/*sizeof(float)*/, l.c, fp);
    fread(l.rolling_variance, 1/*sizeof(float)*/, l.c, fp);
//#ifdef GPU
//    if(gpu_index >= 0){
//        push_batchnorm_layer(l);
//    }
//#endif
}

//void load_convolutional_weights_binary(layer l, FILE *fp)
//{
//    fread(l.biases, 1/*sizeof(float)*/, l.n, fp);
//    if (l.batch_normalize && (!l.dontloadscales)){
//        fread(l.scales, 1/*sizeof(float)*/, l.n, fp);
//        fread(l.rolling_mean, 1/*sizeof(float)*/, l.n, fp);
//        fread(l.rolling_variance, 1/*sizeof(float)*/, l.n, fp);
//    }
//    int size = l.c*l.size*l.size;
//    int i, j, k;
//    for(i = 0; i < l.n; ++i){
//        float mean = 0;
//        fread(&mean, 1/*sizeof(float)*/, 1, fp);
//        for(j = 0; j < size/8; ++j){
//            int index = i*size + j*8;
//            unsigned char c = 0;
//            fread(&c, sizeof(char), 1, fp);
//            for(k = 0; k < 8; ++k){
//                if (j*8 + k >= size) break;
//                l.weights[index + k] = (c & 1<<k) ? mean : -mean;
//            }
//        }
//    }
////#ifdef GPU
////    if(gpu_index >= 0){
////        push_convolutional_layer(l);
////    }
////#endif
//}

static void load_convolutional_weights(layer l, FILE fp) throws IOException
{
    if(l.binary){
        //load_convolutional_weights_binary(l, fp);
        //return;
    }
    int num = l.nweights;
    fread(l.biases, 1/*sizeof(float)*/, l.n, fp);
    if (l.batch_normalize && (!l.dontloadscales)){
        fread(l.scales, 1/*sizeof(float)*/, l.n, fp);
        fread(l.rolling_mean, 1/*sizeof(float)*/, l.n, fp);
        fread(l.rolling_variance, 1/*sizeof(float)*/, l.n, fp);
        if(false/*0*/){
            int i;
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_mean[i]);
            }
            printf("\n");
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_variance[i]);
            }
            printf("\n");
        }
        if(false/*0*/){
            fill_cpu(l.n, 0, l.rolling_mean, 1);
            fill_cpu(l.n, 0, l.rolling_variance, 1);
        }
        if(false/*0*/){
            int i;
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_mean[i]);
            }
            printf("\n");
            for(i = 0; i < l.n; ++i){
                printf("%g, ", l.rolling_variance[i]);
            }
            printf("\n");
        }
    }
    fread(l.weights, 1/*sizeof(float)*/, num, fp);
    //if(l.c == 3) scal_cpu(num, 1./256, l.weights, 1);
    if (l.flipped) {
        transpose_matrix(l.weights, l.c*l.size*l.size, l.n);
    }
    //if (l.binary) binarize_weights(l.weights, l.n, l.c*l.size*l.size, l.weights);
//#ifdef GPU
//    if(gpu_index >= 0){
//        push_convolutional_layer(l);
//    }
//#endif
}


static void load_weights_upto(network net, String filename, int start, int cutoff) throws IOException
{
//#ifdef GPU
//    if(net.gpu_index >= 0){
//        cuda_set_device(net.gpu_index);
//    }
//#endif
    fprintf(stderr, "Loading weights from %s...", filename);
    fflush(stdout);
    FILE fp = fopen(filename, "rb");
    if(null==fp) file_error(filename);

    int major=0;
    int minor=0;
    int revision=0;
    major=fread(major, 1/*sizeof(int)*/, 1, fp);
    minor=fread(minor, 1/*sizeof(int)*/, 1, fp);
    revision=fread(revision, 1/*sizeof(int)*/, 1, fp);
    if ((major*10 + minor) >= 2 && major < 1000 && minor < 1000){
        fread(net.seen, 1/*sizeof(size_t)*/, 1, fp);
    } else {
        int iseen = 0;
        fread(iseen, 1/*sizeof(int)*/, 1, fp);
        net.seen[0] = iseen;
    }
    boolean transpose = (major > 1000) || (minor > 1000);

    int i;
    for(i = start; i < net.n && i < cutoff; ++i){
        layer l = net.layers[i];
        if (l.dontload) continue;
        if(l.type == LAYER_TYPE.CONVOLUTIONAL || l.type == LAYER_TYPE.DECONVOLUTIONAL){
            load_convolutional_weights(l, fp);
        }
        if(l.type == LAYER_TYPE.CONNECTED){
            load_connected_weights(l, fp, transpose);
        }
        if(l.type == LAYER_TYPE.BATCHNORM){
            load_batchnorm_weights(l, fp);
        }
        if(l.type == LAYER_TYPE.CRNN){
            load_convolutional_weights((l.input_layer), fp);
            load_convolutional_weights((l.self_layer), fp);
            load_convolutional_weights((l.output_layer), fp);
        }
        if(l.type == LAYER_TYPE.RNN){
            load_connected_weights((l.input_layer), fp, transpose);
            load_connected_weights((l.self_layer), fp, transpose);
            load_connected_weights((l.output_layer), fp, transpose);
        }
        if (l.type == LAYER_TYPE.LSTM) {
            load_connected_weights((l.wi), fp, transpose);
            load_connected_weights((l.wf), fp, transpose);
            load_connected_weights((l.wo), fp, transpose);
            load_connected_weights((l.wg), fp, transpose);
            load_connected_weights((l.ui), fp, transpose);
            load_connected_weights((l.uf), fp, transpose);
            load_connected_weights((l.uo), fp, transpose);
            load_connected_weights((l.ug), fp, transpose);
        }
        if (l.type == LAYER_TYPE.GRU) {
            if(true/*1*/){
                load_connected_weights((l.wz), fp, transpose);
                load_connected_weights((l.wr), fp, transpose);
                load_connected_weights((l.wh), fp, transpose);
                load_connected_weights((l.uz), fp, transpose);
                load_connected_weights((l.ur), fp, transpose);
                load_connected_weights((l.uh), fp, transpose);
            }else{
                load_connected_weights((l.reset_layer), fp, transpose);
                load_connected_weights((l.update_layer), fp, transpose);
                load_connected_weights((l.state_layer), fp, transpose);
            }
        }
        if(l.type == LAYER_TYPE.LOCAL){
            int locations = l.out_w*l.out_h;
            int size = l.size*l.size*l.c*l.n*locations;
            fread(l.biases, 1/*sizeof(float)*/, l.outputs, fp);
            fread(l.weights, 1/*sizeof(float)*/, size, fp);
//#ifdef GPU
//            if(gpu_index >= 0){
//                push_local_layer(l);
//            }
//#endif
        }
    }
    fprintf(stderr, "Done!\n");
    fclose(fp);
}

public static void load_weights(network net, String filename) throws IOException
{
    load_weights_upto(net, filename, 0, net.n);
}

}
class section{
    String type;
    list options;
}

class size_params{
    int batch;
    int inputs;
    int h;
    int w;
    int c;
    int index;
    int time_steps;
    network net;
}